{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"https://github.com/GeostatsGuy/GeostatsPy/blob/master/TCG_color_logo.png?raw=true\" width=\"220\" height=\"240\" />\n",
    "\n",
    "</p>\n",
    "\n",
    "## Interactive Decision Tree from Predictive Machine Learning\n",
    "\n",
    "\n",
    "### Michael Pyrcz, Professor, University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "\n",
    "### The Interactive Workflow\n",
    "\n",
    "Here's a simple workflow, demonstration of decision trees for subsurface modeling workflows. This should help you get started with building subsurface models that data analytics and machine learning. \n",
    "\n",
    "* I have a lecture on [Decision Trees](https://youtu.be/JUGo1Pu3QT4) as part of my [Machine Learning](https://www.youtube.com/playlist?list=PLG19vXLQHvSC2ZKFIkgVpI9fCjkN38kwf) course. Note, all recorded lectures, interactive and well-documented workflow demononstrations are available on my GitHub repository [GeostatsGuy's Python Numerical Demos](https://github.com/GeostatsGuy/PythonNumericalDemos).\n",
    "\n",
    "* Here's some basic details about predictive machine learning decision tree models. \n",
    "\n",
    "### Decision Tree\n",
    "\n",
    "Machine learning method for supervised learning for classification and regression analysis.  Here are some key aspects of support vector machines.\n",
    "\n",
    "**Prediction**\n",
    "\n",
    "* estimate a function $\\hat{f}$ such that we predict a response feature $Y$ from a set of predictor features $X_1,\\ldots,X_m$. \n",
    "\n",
    "* the prediction is of the form $\\hat{Y} = \\hat{f}(X_1,\\ldots,X_m)$ \n",
    "\n",
    "**Suppervised Learning**\n",
    "\n",
    "* the response feature label, $Y$, is available over the training and testing data\n",
    "    \n",
    "**Hiearchical, Binary Segmentation of the Feature Space**\n",
    "\n",
    "The fundamental idea is to divide the predictor space, $𝑋_1,\\ldots,X_m$, into $J$ mutually exclusive, exhaustive regions\n",
    "\n",
    "* **mutually exclusive** – any combination of predictors only belongs to a single region, $R_j$\n",
    "\n",
    "* **exhaustive** – all combinations of predictors belong a region, $R_j$, regions cover entire feature space (range of the variables being considered)\n",
    "\n",
    "For every observation in a region, $R_j$, we use the same prediction, $\\hat{Y}(R_j)$    \n",
    "\n",
    "For example predict production, $\\hat{Y}$, from porosity, ${X_1}$\n",
    "\n",
    "* given the data within a mD feature space, $X_1,\\ldots,X_m$, find that boundary maximizes the gap between the two categories\n",
    "\n",
    "* new cases are classified based on where they fall relative to this boundary \n",
    "\n",
    "**Compact, Interpretable Model**\n",
    "\n",
    "Since the classification is based on a hierarchy of binary segmentations of the feature space (one feature at a time) the the model can be specified in a intuitive manner as a:\n",
    "\n",
    "* **tree with binary branches**, hence the name decision tree\n",
    "\n",
    "* **set of nested if statements**, for example:\n",
    "\n",
    "```python\n",
    "if porosity > 0.15:\n",
    "    if brittleness < 20:\n",
    "        initial_production = 1000\n",
    "    else:\n",
    "        initial_production = 7000\n",
    "else:\n",
    "    if brittleness < 40:\n",
    "        initial_production = 500\n",
    "    else:\n",
    "        initial_production = 3000\n",
    "```\n",
    "\n",
    "* **predicts with the average of training response features** in each region $\\hat{Y}(R_j)$.   \n",
    "\n",
    "**Proceedure for Tree Construction**\n",
    "\n",
    "The tree is constructed from the top down.  We begin with a sigle region that covers the entire feature space and then proceed with a sequence of splits.\n",
    "\n",
    "* **Scan All Possible Splits** over all regions and over all features.\n",
    "\n",
    "* **Greedy Optimization**  The method proceeds by finding the first segmentation (split) in any feature that minimizes the residual sum of squares of errors over all the training data $y_i$ over all of the regions $j = 1,\\ldots,J$.\n",
    "\n",
    "\\begin{equation}\n",
    "RSS = \\sum^{J}_{j=1} \\sum_{i \\in R_j} (y_i - \\hat{y}_{R_j})^2\n",
    "\\end{equation}\n",
    "\n",
    "* **Stopping Criteria** is typically based on minimum number of training data in each region for a robust estimation and / or minimum reduction in RSS for the next split \n",
    "\n",
    "##### Applications to Subsurface Modeling\n",
    "\n",
    "To provide a wide variety of spatiotemporal  \n",
    "\n",
    "* we work with just 2 predictor features for the example below for easy visualization\n",
    "\n",
    "* flexibility through selection of kernel (hyperparameter) and associated kernel and cost parameters \n",
    "\n",
    "\n",
    "##### Why Cover Decision Trees?\n",
    "\n",
    "They are not the most powerful, cutting edge method in machine learning\n",
    "\n",
    "* but they are likely the most understandable, interpretable  \n",
    "\n",
    "* decision trees are expanded with random forests, bagging and boosting to be cutting edge  \n",
    "\n",
    "\n",
    "#### Getting Started\n",
    "\n",
    "Here's the steps to get setup in Python with the GeostatsPy package:\n",
    "\n",
    "1. Install Anaconda 3 on your machine (https://www.anaconda.com/download/). \n",
    "2. From Anaconda Navigator (within Anaconda3 group), go to the environment tab, click on base (root) green arrow and open a terminal. \n",
    "3. In the terminal type: pip install geostatspy. \n",
    "4. Open Jupyter and in the top block get started by copy and pasting the code block below from this Jupyter Notebook to start using the geostatspy functionality. \n",
    "\n",
    "You may want to copy the data file to your working directory. They are available here:\n",
    "\n",
    "* Tabular data - unconv_MV.csv at https://git.io/fjmBH.\n",
    "\n",
    "or you can use the code below to load the data directly from my GitHub [GeoDataSets](https://github.com/GeostatsGuy/GeoDataSets) repository.\n",
    "\n",
    "#### Install Packages\n",
    "\n",
    "We will include the standard packages for DataFrames and ndarrays and add sci-kit-learn (sklearn) for machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "supress_warnings = False\n",
    "import os                                               # to set current working directory \n",
    "import sys                                              # supress output to screen for interactive variogram modeling\n",
    "import numpy as np                                      # arrays and matrix math\n",
    "import pandas as pd                                     # DataFrames\n",
    "import matplotlib.pyplot as plt                         # plotting\n",
    "from sklearn.model_selection import train_test_split    # train and test split\n",
    "from sklearn import tree                                # tree program from scikit learn (package for machine learning)\n",
    "from sklearn import metrics                             # measures to check our models\n",
    "from matplotlib.patches import Rectangle                # build a custom legend\n",
    "from matplotlib.ticker import (MultipleLocator, AutoMinorLocator) # control of axes ticks\n",
    "import math                                             # sqrt operator\n",
    "from ipywidgets import interactive                      # widgets and interactivity\n",
    "from ipywidgets import widgets                            \n",
    "from ipywidgets import Layout\n",
    "from ipywidgets import Label\n",
    "from ipywidgets import VBox, HBox\n",
    "cmap = plt.cm.inferno                                   # default color bar, no bias and friendly for color vision defeciency\n",
    "plt.rc('axes', axisbelow=True)                          # grid behind plotting elements\n",
    "if supress_warnings == True:\n",
    "    import warnings                                     # supress any warnings for this demonstration\n",
    "    warnings.filterwarnings('ignore')                       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs.  \n",
    "\n",
    "#### Declare Functions\n",
    "\n",
    "These are functions that I wrote (with one exception) to diagnose and visualize decision tree models.\n",
    "\n",
    "* **extract_rules** - recursive function to get the rules for each devision tree region as a set of conditional statements. Note there is some repeat. I found this on Stack Overflow (I think paulkernfeld was the author).\n",
    "\n",
    "* **plot_decision_tree_regions** - inspired by rstats' tree package, this function takes the extract_rules output to add the tree prediction regions to a plot. Note, only works with 2 predictor features.\n",
    "\n",
    "* **visualize_tree_model** - plot the data in feature space and a grid of the tree predictions. Note, only works for 2 predictor features.\n",
    "\n",
    "* **check_tree_model** - cross validation plot with prediction vs. true for testing and training data. Shows the region values and conditional statistics for the true values in each region (P10, mean and P90)\n",
    "\n",
    "* **tree_tuning** - vary the tree complexity via the number of regions (a.k.a. max_leaf_nodes) hyperparameter and plot the mean square error (MSE) training and testing along with the currently displayed model to visually hyperparameter tune.\n",
    "\n",
    "I'm stoked about these functions. They provide a great improvement in diagnosing and visualizing decision tree models in predictive machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_rules(tree_model, feature_names):           # recursive method to extract rules, from paulkernfeld Stack Overflow (?)\n",
    "    rules = []\n",
    "    def traverse(node, depth, prev_rule):\n",
    "        if tree_model.tree_.children_left[node] == -1:  # Leaf node\n",
    "            class_label = np.argmax(tree_model.tree_.value[node])\n",
    "            rule = f\"{prev_rule} => Class {class_label}\"\n",
    "            rules.append(rule)\n",
    "        else:  # Split node\n",
    "            feature = feature_names[tree_model.tree_.feature[node]]\n",
    "            threshold = tree_model.tree_.threshold[node]\n",
    "            left_child = tree_model.tree_.children_left[node]\n",
    "            right_child = tree_model.tree_.children_right[node]\n",
    "\n",
    "            # Recursively traverse left and right subtrees\n",
    "            traverse(left_child, depth + 1, f\"{prev_rule} & {feature} <= {threshold}\")\n",
    "            traverse(right_child, depth + 1, f\"{prev_rule} & {feature} > {threshold}\")\n",
    "    traverse(0, 0, \"Root\")\n",
    "    return rules\n",
    "\n",
    "def plot_decision_tree_regions(tree_model, feature_names,X_min,X_max):\n",
    "    rules = extract_rules(tree_model, feature_names)\n",
    "    for irule, ____ in enumerate(rules):\n",
    "        rule = rules[irule].split()[2:]\n",
    "        X_min = Xmin[0]; X_max = Xmax[0]; Y_min = Xmin[1]; Y_max = Xmax[1];\n",
    "        index = [i for i,val in enumerate(rule) if val==feature_names[0]]\n",
    "        for i in index:\n",
    "            if rule[i+1] == '<=':\n",
    "                X_max = min(float(rule[i+2]),X_max)\n",
    "            else:\n",
    "                X_min = max(float(rule[i+2]),X_min)\n",
    "        index = [i for i,val in enumerate(rule) if val==feature_names[1]]\n",
    "        for i in index:\n",
    "            if rule[i+1] == '<=':\n",
    "                Y_max = min(float(rule[i+2]),Y_max)\n",
    "            else:\n",
    "                Y_min = max(float(rule[i+2]),Y_min) \n",
    "        plt.gca().add_patch(plt.Rectangle((X_min,Y_min),X_max-X_min,Y_max-Y_min, lw=2,ec='black',fc=\"none\"))\n",
    "        cx = (X_min + X_max)*0.5; cy = (Y_min + Y_max)*0.5; loc = np.array((cx,cy)).reshape(1, -1)\n",
    "        plt.annotate(text = str(np.round(tree_model.predict(loc)[0],2)),xy=(cx,cy),ha='center',weight='bold',c='white',zorder=100)\n",
    "\n",
    "def visualize_tree_model(model,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title,Xname,yname,Xlabel,ylabel):# plots the data points and the decision tree prediction \n",
    "    cmap = plt.cm.inferno\n",
    "    X1plot_step = (Xmax[0] - Xmin[0])/300.0; X2plot_step = -1*(Xmax[1] - Xmin[1])/300.0 # resolution of the model visualization\n",
    "    XX1, XX2 = np.meshgrid(np.arange(Xmin[0], Xmax[0], X1plot_step), # set up the mesh\n",
    "                     np.arange(Xmax[1], Xmin[1], X2plot_step))\n",
    "    y_hat = model.predict(np.c_[XX1.ravel(), XX2.ravel()]) # predict with our trained model over the mesh\n",
    "    y_hat = y_hat.reshape(XX1.shape)\n",
    "\n",
    "    plt.imshow(y_hat,interpolation=None, aspect=\"auto\", extent=[Xmin[0],Xmax[0],Xmin[1],Xmax[1]], \n",
    "        vmin=ymin,vmax=ymax,alpha = 0.2,cmap=cmap,zorder=1)\n",
    "    sp = plt.scatter(X1_train,X2_train,s=None, c=y_train, marker='o', cmap=cmap, \n",
    "        norm=None, vmin=ymin, vmax=ymax, alpha=0.6, linewidths=0.3, edgecolors=\"black\", label = 'Train',zorder=10)\n",
    "    plt.scatter(X1_test,X2_test,s=None, c=y_test, marker='s', cmap=cmap, \n",
    "        norm=None, vmin=ymin, vmax=ymax, alpha=0.3, linewidths=0.3, edgecolors=\"black\", label = 'Test',zorder=10)\n",
    "\n",
    "    plot_decision_tree_regions(model,Xname,Xmin,Xmax)\n",
    "    plt.title(title); plt.xlabel(Xlabel[0]); plt.ylabel(Xlabel[1])\n",
    "    plt.xlim([Xmin[0],Xmax[0]]); plt.ylim([Xmin[1],Xmax[1]])\n",
    "    cbar = plt.colorbar(sp, orientation = 'vertical')   # add the color bar\n",
    "    cbar.set_label(ylabel, rotation=270, labelpad=20)\n",
    "    return y_hat\n",
    "\n",
    "def check_tree_model(model,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title):    # plots the estimated vs. the actual  \n",
    "    y_hat_train = model.predict(np.c_[X1_train,X2_train]); y_hat_test = model.predict(np.c_[X1_test,X2_test])\n",
    "\n",
    "    df_cross = pd.DataFrame(np.c_[y_test,y_hat_test],columns=['y_test','y_hat_test'])\n",
    "    df_cross_train = pd.DataFrame(np.c_[y_train,y_hat_train],columns=['y_train','y_hat_train'])\n",
    "\n",
    "    plt.scatter(y_train,y_hat_train,s=15, c='blue',marker='o', cmap=None, norm=None, vmin=None, vmax=None, alpha=0.7, \n",
    "                linewidths=0.3, edgecolors=\"black\",label='Train',zorder=10)\n",
    "    plt.scatter(y_test,y_hat_test,s=15, c='red',marker='s', cmap=None, norm=None, vmin=None, vmax=None, alpha=0.7, \n",
    "                linewidths=0.3, edgecolors=\"black\",label='Test',zorder=10)\n",
    "\n",
    "    unique_y_hat_all = set(np.concatenate([y_hat_test,y_hat_train]))\n",
    "    for y_hat in unique_y_hat_all:\n",
    "        plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.2,ls='--',zorder=1)\n",
    "        \n",
    "    unique_y_hat_test = set(y_hat_test)\n",
    "    for y_hat in unique_y_hat_test:\n",
    "        #plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.3,ls='--',zorder=1)\n",
    "        cond_mean_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].mean()\n",
    "        cond_P75_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].quantile(0.75)\n",
    "        cond_P25_y_hat = df_cross.loc[df_cross['y_hat_test'] == y_hat, 'y_test'].quantile(0.25)\n",
    "        plt.scatter(cond_mean_y_hat,y_hat-0.02*(ymax-ymin),color='red',edgecolor='black',s=60,marker='^',zorder=100)\n",
    "        plt.plot([cond_P25_y_hat,cond_P75_y_hat],[y_hat-0.025*(ymax-ymin),y_hat-0.025*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P25_y_hat,cond_P25_y_hat],[y_hat-0.032*(ymax-ymin),y_hat-0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P75_y_hat,cond_P75_y_hat],[y_hat-0.032*(ymax-ymin),y_hat-0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        \n",
    "    unique_y_hat_train = set(y_hat_train)\n",
    "    for y_hat in unique_y_hat_train:\n",
    "        #plt.plot([ymin,ymax],[y_hat,y_hat],c='black',alpha=0.3,ls='--',zorder=1)\n",
    "        cond_mean_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].mean()\n",
    "        cond_P75_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].quantile(0.75)\n",
    "        cond_P25_y_hat = df_cross_train.loc[df_cross_train['y_hat_train'] == y_hat, 'y_train'].quantile(0.25)\n",
    "        plt.scatter(cond_mean_y_hat,y_hat+0.02*(ymax-ymin),color='blue',edgecolor='black',s=60,marker='v',zorder=100)\n",
    "        plt.plot([cond_P25_y_hat,cond_P75_y_hat],[y_hat+0.025*(ymax-ymin),y_hat+0.025*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P25_y_hat,cond_P25_y_hat],[y_hat+0.032*(ymax-ymin),y_hat+0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        plt.plot([cond_P75_y_hat,cond_P75_y_hat],[y_hat+0.032*(ymax-ymin),y_hat+0.018*(ymax-ymin)],c='black',lw=0.7)\n",
    "        \n",
    "    plt.title(title); plt.xlabel('Actual Production (MCFPD)'); plt.ylabel('Estimated Production (MCFPD)')\n",
    "    plt.xlim([ymin,ymax]); plt.ylim([ymin,ymax]); plt.legend(loc='upper left')\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks\n",
    "\n",
    "    plt.arrow(ymin,ymin,ymax,ymax,width=0.02,color='black',head_length=0.0,head_width=0.0)\n",
    "    MSE_train = metrics.mean_squared_error(y_train,y_hat_train); MSE_test = metrics.mean_squared_error(y_test,y_hat_test)\n",
    "    Var_Explained = metrics.explained_variance_score(y_test,y_hat_test)\n",
    "    cor = math.sqrt(metrics.r2_score(y_test,y_hat_test))\n",
    "    plt.gca().add_patch(plt.Rectangle((ymin+0.6*(ymax-ymin),ymin+0.1*(ymax-ymin)),0.40*(ymax-ymin),0.12*(ymax-ymin),\n",
    "        lw=0.5,ec='black',fc=\"white\",zorder=100))\n",
    "    plt.annotate('MSE Testing: ' + str(np.round(MSE_test,2)),(ymin+0.62*(ymax-ymin),ymin+0.18*(ymax-ymin)),zorder=1000)\n",
    "    plt.annotate('MSE Training: ' + str(np.round(MSE_train,2)),(ymin+0.62*(ymax-ymin),ymin+0.12*(ymax-ymin)),zorder=1000)\n",
    "    \n",
    "def tree_tuning(node_max,cnode,X1_train,X1_test,X2_train,X2_test,Xmin,Xmax,y_train,y_test,ymin,ymax,title,seed):\n",
    "    MSE_test_mat = np.zeros(node_max-1); MSE_train_mat = np.zeros(node_max-1);\n",
    "    \n",
    "    for imax_leaf_node, max_leaf_node in enumerate(range(2,node_max+1)):\n",
    "        np.random.seed(seed = seed)\n",
    "        tree_temp = tree.DecisionTreeRegressor(max_leaf_nodes = max_leaf_node)\n",
    "        tree_temp = tree_temp.fit(X_train.values, y_train.values)\n",
    "        y_hat_train = tree_temp.predict(np.c_[X1_train,X2_train]); y_hat_test = tree_temp.predict(np.c_[X1_test,X2_test])  \n",
    "        MSE_train_mat[imax_leaf_node] = metrics.mean_squared_error(y_train,y_hat_train)\n",
    "        MSE_test_mat[imax_leaf_node] = metrics.mean_squared_error(y_test,y_hat_test)\n",
    "        if max_leaf_node == cnode:\n",
    "            plt.scatter(cnode,MSE_train_mat[imax_leaf_node],color='blue',edgecolor='black',s=20,marker='o',zorder=1000)\n",
    "            plt.scatter(cnode,MSE_test_mat[imax_leaf_node],color='red',edgecolor='black',s=20,marker='o',zorder=1000)\n",
    "    maxcheck = max(np.max(MSE_train_mat),np.max(MSE_test_mat))\n",
    "    \n",
    "    plt.vlines(cnode,0,maxcheck,color='black',ls='--',lw=1,zorder=1) \n",
    "    plt.plot(range(2,node_max+1),MSE_train_mat,color='blue',zorder=100,label='Train')\n",
    "    plt.plot(range(2,node_max+1),MSE_test_mat,color='red',zorder=100,label='Test')\n",
    "    \n",
    "    plt.title(title); plt.xlabel('Maximum Number of Leaf Nodes'); plt.ylabel('Means Square Error')\n",
    "    plt.xlim([0,node_max]); plt.ylim([0,maxcheck]); plt.legend(loc='upper right')\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Data\n",
    "\n",
    "Let's load the provided multivariate, spatial dataset [unconv_MV.csv](https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/unconv_MV.csv) available in my GeoDataSet repo. It is a comma delimited file with: \n",
    "\n",
    "* well index (integer)\n",
    "* porosity (fraction)\n",
    "* permeability ($mD$)\n",
    "* acoustic impedance ($\\frac{kg}{m^3} \\cdot \\frac{m}{s} \\cdot 10^6$). \n",
    "* total organic carbon (%)\n",
    "* vitrinite reflectance (%)\n",
    "* initial gass production (90 day average) (MCFPD)\n",
    "\n",
    "We load it with the pandas 'read_csv' function into a data frame we called 'df' and then preview it to make sure it loaded correctly.\n",
    "\n",
    "**Python Tip: using functions from a package** just type the label for the package that we declared at the beginning:\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "```\n",
    "\n",
    "so we can access the pandas function 'read_csv' with the command: \n",
    "\n",
    "```python\n",
    "pd.read_csv()\n",
    "```\n",
    "\n",
    "but read csv has required input parameters. The essential one is the name of the file. For our circumstance all the other default parameters are fine. If you want to see all the possible parameters for this function, just go to the docs [here](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html).  \n",
    "\n",
    "* The docs are always helpful\n",
    "* There is often a lot of flexibility for Python functions, possible through using various inputs parameters\n",
    "\n",
    "also, the program has an output, a pandas DataFrame loaded from the data.  So we have to specficy the name / variable representing that new object.\n",
    "\n",
    "```python\n",
    "df = pd.read_csv(\"unconv_MV.csv\")  \n",
    "```\n",
    "\n",
    "Let's run this command to load the data and then this command to extract a random subset of the data.\n",
    "\n",
    "```python\n",
    "df = df.sample(frac=.30, random_state = 73073); \n",
    "df = df.reset_index()\n",
    "```\n",
    "\n",
    "#### Feature Engineering\n",
    "\n",
    "Let's make some changes to the data to improve the workflow:\n",
    "\n",
    "* **Select the predictor features (x2) and the response feature (x1)**, make sure the metadata is also consistent.\n",
    "* **Metadata** encoding such as the units, labels and display ranges for each feature.\n",
    "* **Reduce the number of data** for ease of visualization (hard to see if too many points on our plots).\n",
    "* **Train and test data split** to demonstrate and visualize simple hyperparameter tuning.\n",
    "* **Add random noise to the data** to demonstrate model overfit. The original data is error free and does not readily demonstrate overfit.\n",
    "\n",
    "Given this is properly set, one should be able to use any dataset and features for this demonstration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "add_error = True                                        # add random error to the response feature\n",
    "std_error = 700; seed = 71071\n",
    "\n",
    "yname = 'Production'; Xname = ['Por','Brittle']         # specify the predictor features (x2) and response feature (x1)\n",
    "Xmin = [5.0,0.0]; Xmax = [25.0,100.0]                   # set minumums and maximums for visualization \n",
    "ymin = 0.0; ymax = 10000.0\n",
    "Xlabel = ['Porosity','Brittleness']; ylabel = 'Production' # specify the feature labels for plotting\n",
    "Xunit = ['%','fraction']; yunit = 'MCFPD'\n",
    "Xlabelunit = [Xlabel[0] + ' (' + Xunit[0] + ')',Xlabel[1] + ' (' + Xunit[1] + ')']\n",
    "ylabelunit = ylabel + ' (' + yunit + ')'\n",
    "\n",
    "#df = pd.read_csv(\"unconv_MV.csv\")                      # load the data from local current directory\n",
    "df = pd.read_csv(r\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/unconv_MV.csv\") # load the data from my github repo\n",
    "df = df.sample(frac=.30, random_state = 73073); df = df.reset_index() # extract 30% random to reduce the number of data\n",
    "\n",
    "if add_error == True:                                   # method to add error\n",
    "    np.random.seed(seed=seed)                           # set random number seed\n",
    "    df[yname] = df[yname] + np.random.normal(loc = 0.0,scale=std_error,size=len(df)) # add noise\n",
    "    values = df._get_numeric_data(); values[values < 0] = 0  # set negative to 0 in a shallow copy ndarray\n",
    "    \n",
    "y = pd.DataFrame(df[yname])                             # extract selected features as X and y DataFrames\n",
    "X = df[Xname]\n",
    "df = pd.concat([X,y],axis=1)                            # make one DataFrame with both X and y (remove all other features)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.25,random_state=73073) # train and test split\n",
    "# y_train = pd.DataFrame({yname:y_train.values}); y_test = pd.DataFrame({yname:y_test.values}) # optional to ensure response is a DataFrame\n",
    "\n",
    "plt.subplot(121)                                        # visualize the data\n",
    "im = plt.scatter(X_train[Xname[0]],X_train[Xname[1]],s=None, c=y_train[yname], marker='o', cmap=cmap, \n",
    "    norm=None, vmin=ymin, vmax=ymax, alpha=0.8, linewidths=0.3, edgecolors=\"black\", label = 'Train')\n",
    "plt.scatter(X_test[Xname[0]],X_test[Xname[1]],s=None, c=y_test[yname], marker='s', cmap=cmap, \n",
    "    norm=None, vmin=ymin, vmax=ymax, alpha=0.5, linewidths=0.3, edgecolors=\"black\", label = 'Test')\n",
    "plt.title('Training ' + ylabel + ' vs. ' + Xlabel[1] + ' and ' + Xlabel[0]); \n",
    "plt.xlabel(Xlabel[0] + ' (' + Xunit[0] + ')'); plt.ylabel(Xlabel[1] + ' (' + Xunit[1] + ')')\n",
    "plt.xlim(Xmin[0],Xmax[0]); plt.ylim(Xmin[1],Xmax[1]); plt.legend(loc = 'upper right'); plt.grid(True)\n",
    "cbar = plt.colorbar(im, orientation = 'vertical')\n",
    "cbar.set_label(ylabel + ' (' + yunit + ')', rotation=270, labelpad=20)\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.2, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive Decision Tree Method\n",
    "\n",
    "The following code includes a dashboard with widgets linked to plots to run a decision tree predictive machine learning model and to provide diagnostics.\n",
    "\n",
    "* visualization of the decision tree regions with the estimate in each region annotated\n",
    "* cross validation plot with conditional mean, P10 and P90 of the truth for each possible estimate\n",
    "* the MSE train and test curves for hyperparameter tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = widgets.Text(value='                                                Machine Learning Decision Tree Demo, Prof. Michael Pyrcz, The University of Texas at Austin',\n",
    "        layout=Layout(width='970px', height='30px'))\n",
    "\n",
    "max_leaf_nodes = widgets.IntSlider(min=2, max = 150, value=2, step = 1, description = r'$n_{leaf}$',orientation='horizontal', \n",
    "        style = {'description_width': 'initial'},layout=Layout(width='900px', height='30px'),continuous_update=False)\n",
    "\n",
    "ui_summary = widgets.HBox([max_leaf_nodes,],)\n",
    "ui2_summary = widgets.VBox([l,ui_summary],)\n",
    "\n",
    "def run_plot_summary(max_leaf_nodes):\n",
    "    global tree_model                                   # make the current tree model available for additional visualizations\n",
    "    tree_model = tree.DecisionTreeRegressor(max_leaf_nodes = max_leaf_nodes) # instantiate and train tree model\n",
    "    tree_model = tree_model.fit(X_train.values, y_train.values)\n",
    "    \n",
    "    plt.subplot(131)                                    # visualize, data, and decision tree regions and predictions\n",
    "    visualize_tree_model(tree_model,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model',Xname,yname,Xlabelunit,ylabelunit) # plots the data points and the decision tree prediction \n",
    "    \n",
    "    plt.subplot(132)                                    # cross validation with conditional statistics plot\n",
    "    check_tree_model(tree_model,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model',)\n",
    "    \n",
    "    plt.subplot(133)                                    # hyperparameter tuning plot with current result plotted\n",
    "    tree_tuning(100,max_leaf_nodes,X_train[Xname[0]],X_test[Xname[0]],X_train[Xname[1]],X_test[Xname[1]],Xmin,Xmax,\n",
    "                    y_train[yname],y_test[yname],ymin,ymax,'Decision Tree Model Error',seed)\n",
    "    \n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=3.0, top=1.2, wspace=0.3, hspace=0.2); plt.show()\n",
    "    \n",
    "    return tree_model\n",
    "    \n",
    "# connect the function to make the samples and plot to the widgets    \n",
    "interactive_plot_summary = widgets.interactive_output(run_plot_summary, {'max_leaf_nodes':max_leaf_nodes,})\n",
    "interactive_plot_summary.clear_output(wait = True)                  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Decision Tree Demonstration\n",
    "\n",
    "* select maximum number of leaf nodes, $n_{leaf}$, and observe the decision tree model, cross validation plot and entire training and testing error curves.\n",
    "\n",
    "#### Michael Pyrcz, Professor, University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1) | [GeostatsPy](https://github.com/GeostatsGuy/GeostatsPy)\n",
    "\n",
    "### The Inputs\n",
    "\n",
    "Change the complexity of the decision tree model\n",
    "\n",
    "* $n_{leaf}$: the maximum number of leaf nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "89da3fe981ee405499a8dbb2ba5100b7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Text(value='                                                Machine Learning Decision Tree Demo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24973261c6124fc09e5611c16a100b00",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output(outputs=({'output_type': 'display_data', 'data': {'text/plain': '<Figure size 432x288 with 4 Axes>', 'i…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(ui2_summary, interactive_plot_summary)                           # display the interactive plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Additional Tree Model Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(tree_model,label='none',impurity=False)\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.0, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comments\n",
    "\n",
    "This was an interactive demonstration of predictive machine learning with decision trees. Much more could be done, I have other demonstrations on the basics of working with DataFrames, ndarrays, univariate statistics, plotting data, declustering, data transformations and many other workflows available at https://github.com/GeostatsGuy/PythonNumericalDemos and https://github.com/GeostatsGuy/GeostatsPy. \n",
    "  \n",
    "#### The Author:\n",
    "\n",
    "### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "*Novel Data Analytics, Geostatistics and Machine Learning Subsurface Solutions*\n",
    "\n",
    "With over 17 years of experience in subsurface consulting, research and development, Michael has returned to academia driven by his passion for teaching and enthusiasm for enhancing engineers' and geoscientists' impact in subsurface resource development. \n",
    "\n",
    "For more about Michael check out these links:\n",
    "\n",
    "#### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "#### Want to Work Together?\n",
    "\n",
    "I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.\n",
    "\n",
    "* Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you! \n",
    "\n",
    "* Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PIs including Profs. Foster, Torres-Verdin and van Oort)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!\n",
    "\n",
    "* I can be reached at mpyrcz@austin.utexas.edu.\n",
    "\n",
    "I'm always happy to discuss,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "Michael Pyrcz, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin\n",
    "\n",
    "#### More Resources Available at: [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)  \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
